A Virtual Machine is software used by many programming platforms to execute application programs. Dynamic compilers are commonly used within Virtual Machines to speed up program execution. Generally, programmers convert applications written in a programming language for such platform, to a stream of bytecodes. Such bytecodes can be run on any computer that has a Virtual Machine installed on it. The Virtual Machine reads the bytecode stream and invokes an Interpreter to execute the bytecodes sequentially. The Virtual Machine then identifies regions of bytecodes whose execution is performance-critical and invokes the dynamic compiler to compile such regions into code that represents a faster version of the supplied region. Compiled code is not interpreted, but directly executed by the computer's underlying processor. The Interpreter transfers control to the compiled code for subsequent execution of such regions, greatly boosting overall execution performance.
Sometimes, the dynamic compiler can crash while compiling a region of bytecode. Because the compiler works alongside the Virtual Machine, a fatal error in the compiler can cause the Virtual Machine to crash as well, terminating the execution of the application. One solution to this problem is, after the application crashes, identifying all error-prone regions of bytecodes, and excluding compilation attempts of such regions in subsequent runs. However, creating such exclusion lists is often manual and hence inefficient, and completely excluding compilation of such regions in subsequent runs may lead to significant performance degradation, since the regions will now be executed by the Interpreter.
Base on the foregoing, it is desirable that mechanisms be provided to solve the above deficiencies and related problems.